from dbutils.pooled_db import PooledDB  # 同步连接池
import pymysql

# 导入几个常用的类型标注工具
# List：标注 “列表” 类型，指定列表中元素的类型。
# Tuple：标注 “元组” 类型，指定元组中各位置元素的类型。
# ptional：标注 “可选类型”，表示某个参数或变量可以是指定类型，也可以是 None。
# Any：标注 “任意类型”，表示不限制具体类型（用于无法或无需明确类型的场景）
from typing import List, Tuple, Optional, Any
import aiomysql #协程异步连接池
# 日志
import logging
logger = logging.getLogger(__name__)


from sql_yu_ju import SQL_YU_JI_l
import asyncio  #协程异步

# MYSQL协程异步连接池
class AsyncMYSQL_CZ:
    """异步 MySQL 数据库操作类"""

    # 数据库连接配置
    __host = '192.168.1.88'
    __port = 3306
    __database = 'zhi_neng_wang_guan'
    __user = 'a18222970'
    __password = 'cx123100'

    # 异步连接池实例
    '''
     __pool: Optional[aiomysql.Pool] = None
    声明一个类级别的私有变量 __pool，它可以存储 aiomysql 连接池实例（aiomysql.Pool 类型）或 None（未初始化状态），
    初始值为 None，用于管理数据库连接池的生命周期（创建、使用、关闭）。这种设计确保了连接池的安全复用和状态可控，
    是异步数据库操作中常见的资源管理模式
     : 在此处是类型提示的语法符号，用于为变量 __pool 声明其预期的类型（aiomysql.Pool 或 None）
    '''
    __pool: Optional[aiomysql.Pool] = None

    '''
    cls 是 类方法（Class Method） 的第一个参数，代表类本身（即 AsyncMYSQL_CZ 类）。
    类方法需要通过 @classmethod 装饰器声明，其核心作用是操作类级别的属性（如类变量）或行为（如创建类实例）。
    类变量（如 __pool、__host 等）是属于类的，所有实例共享同一份。通过 cls 可以直接访问和修改这些类变量,
    类方法可以直接通过类名调用（如 AsyncMYSQL_CZ.create_pool()），无需创建类的实例。
    '''
    @classmethod  # 有此装饰器的,第一个参数为cls,没有此装饰器的第一个参数为self
    async def create_pool(cls):
        """创建异步连接池（推荐在程序启动时调用）
        aiomysql.create_pool：aiomysql 库提供的异步函数，用于创建 MySQL 数据库连接池
        """
        cls.__pool = await aiomysql.create_pool(
            host=cls.__host,
            port=cls.__port,
            user=cls.__user,
            password=cls.__password,
            db=cls.__database,
            minsize=1,  # 最小连接数（相当于 mincached）
            maxsize=6,  # 最大连接数（相当于 maxconnections）
            autocommit=False,  # 关闭自动提交
            pool_recycle=300  # 连接回收时间（秒）
        )

    @classmethod
    async def close_pool(cls):
        """关闭连接池（推荐在程序退出时调用）"""
        if cls.__pool:
            #标记连接池为 “关闭状态”，停止接受新的连接请求,这是一个同步操作（无需 await）
            # close() 是 aiomysql.Pool 类的方法，调用后连接池会拒绝新的连接请求（如 acquire() 获取连接会失败），
            # 但不会立即关闭所有正在使用的连接
            cls.__pool.close()
            # 异步等待连接池完全关闭（所有连接被释放）
            await cls.__pool.wait_closed()

    """
    sql: str：要执行的 SQL 查询语句
    params: tuple = None：SQL 语句的参数（可选），用于填充 SQL 中的占位符（如 %s）。默认值为 None，表示无参数。
    -> 符号：这是 Python 的函数返回值类型标注语法，用于声明函数返回值的类型
    -> Optional[List[Tuple]] 表示函数返回值的类型
        成功时：返回一个 List[Tuple]（元组列表）
        失败时：返回 None（如连接池未初始化、SQL 执行错误等）
    """
    async def execute_query(self, sql: str, params: tuple = None) -> Optional[List[Tuple]]:
        """
        通用异步查询方法
        :param sql: SQL 查询语句
        :param params: 查询参数
        :return: 查询结果列表或 None（失败时）
        """
        if not self.__pool:
            raise RuntimeError("连接池未初始化，请先调用 create_pool()")
        # async with 上下文管理器：确保连接和游标在代码块执行完毕后自动释放（归还给连接池或关闭），避免资源泄漏
        # self.__pool.acquire()：从连接池中异步获取一个数据库连接（aiomysql.Connection 对象
        # as 关键字的作用是将异步上下文管理器返回的资源对象（这里是数据库连接）绑定到一个变量（conn）
        async with self.__pool.acquire() as conn:
            # conn.cursor()：通过连接创建一个游标（aiomysql.Cursor 对象），游标是执行 SQL 语句和获取结果的接口
            async with conn.cursor() as cursor:
                try:
                    # cursor.execute(sql, params)：异步执行 SQL 语句。params 用于填充 SQL 中的占位符（如 %s），
                    # 这种方式可以防止 SQL 注入攻击（替代直接拼接字符串
                    # 若 params 为 None，则 params or () 会将其转换为空元组（()），避免 execute 方法因参数缺失报错
                    await cursor.execute(sql, params or ())
                    # cursor.fetchall()：异步获取所有查询结果（即数据库返回的所有行）。返回值是一个元组列表
                    result = await cursor.fetchall()
                    return result
                except aiomysql.OperationalError as e:
                    # 处理数据库连接相关错误（如连接超时、权限不足）
                    error_code, error_msg = e.args
                    print(f"数据库操作错误 [{error_code}]: {error_msg}")
                    logger.error(f"数据库操作错误 [{error_code}]: {error_msg}")
                    if error_code in (2003, 2006, 2013):  # 连接拒绝/丢失
                        print("⚠️ 数据库连接失败，请检查主机、端口和权限")
                    return None
                except aiomysql.ProgrammingError as e:
                    # 处理SQL语法错误或参数不匹配
                    error_code, error_msg = e.args
                    print(f"SQL编程错误 [{error_code}]: {error_msg}")
                    print(f"错误SQL: {sql}")
                    print(f"参数: {params}")
                    logger.error(f"SQL编程错误 [{error_code}]: {error_msg}")
                    return None
                except aiomysql.IntegrityError as e:
                    # 处理数据完整性错误（如唯一约束冲突、外键失败）
                    error_code, error_msg = e.args
                    print(f"数据完整性错误 [{error_code}]: {error_msg}")
                    logger.error(f"数据完整性错误 [{error_code}]: {error_msg}")
                    return None
                except aiomysql.Error as e:
                    # 处理其他MySQL错误
                    error_code, error_msg = e.args
                    print(f"未知MySQL错误 [{error_code}]: {error_msg}")
                    logger.error(f"未知MySQL错误 [{error_code}]: {error_msg}")
                    return None
                except Exception as e:
                    # 处理非MySQL相关错误（如网络中断）
                    error_code, error_msg = e.args
                    print(f"执行查询时发生意外错误: {e}")
                    logger.error(f"执行查询时发生意外错误 [{error_code}]: {error_msg}")
                    return None

    async def execute_update(self, sql: str, params: tuple = None) -> bool:
        """
        通用异步更新/插入方法
        :param sql: SQL 语句
        :param params: 参数
        :return: 执行是否成功
        """
        if not self.__pool:
            raise RuntimeError("连接池未初始化，请先调用 create_pool()")

        async with self.__pool.acquire() as conn:
            async with conn.cursor() as cursor:
                try:
                    await cursor.execute(sql, params or ())
                    # 将当前事务中所有未提交的数据库更改（如插入、更新、删除）永久保存到数据库
                    await conn.commit()
                    return True
                except aiomysql.OperationalError as e:
                    error_code, error_msg = e.args
                    print(f"数据库操作错误 [{error_code}]: {error_msg}")
                    await conn.rollback() # 回滚,撤销,提交的修改
                    return False
                except aiomysql.ProgrammingError as e:
                    error_code, error_msg = e.args
                    print(f"SQL编程错误 [{error_code}]: {error_msg}")
                    print(f"错误SQL: {sql}")
                    print(f"参数: {params}")
                    await conn.rollback()# 回滚,撤销,提交的修改
                    return False
                except aiomysql.IntegrityError as e:
                    error_code, error_msg = e.args
                    print(f"数据完整性错误 [{error_code}]: {error_msg}")
                    await conn.rollback()# 回滚,撤销,提交的修改
                    return False
                except aiomysql.Error as e:
                    error_code, error_msg = e.args
                    print(f"未知MySQL错误 [{error_code}]: {error_msg}")
                    await conn.rollback()# 回滚,撤销,提交的修改
                    return False
                except Exception as e:
                    print(f"执行更新时发生意外错误: {e}")
                    await conn.rollback()# 回滚,撤销,提交的修改
                    return False

    async def execute_update(self, sql_operations: List[Tuple[str, tuple]]) -> bool:
        """
        通用异步更新/插入方法，支持多个相关操作的事务控制
        :param sql_operations: 包含SQL语句及其参数的元组列表 [(sql1, params1), (sql2, params2), ...]
        :return: 执行是否成功
        """
        if not self.__pool:
            raise RuntimeError("连接池未初始化，请先调用 create_pool()")

        async with self.__pool.acquire() as conn:
            try:
                # 开始事务
                await conn.begin()

                for sql, params in sql_operations:
                    async with conn.cursor() as cursor:
                        try:
                            await cursor.execute(sql, params or ())
                        except aiomysql.Error as e:
                            # 记录详细的错误信息
                            logger.error(f"执行SQL时出错: {sql}, 参数: {params}, 错误: {e}")
                            # 回滚事务
                            await conn.rollback()
                            logger.error("事务已回滚，原因是SQL执行错误")
                            return False

                # 所有操作成功，提交事务
                await conn.commit()
                logger.info("事务已成功提交")
                return True

            except Exception as e:
                # 记录其他异常信息
                logger.error(f"执行事务时发生意外错误: {e}")
                # 回滚事务
                await conn.rollback()
                logger.error("事务已回滚，原因是发生意外错误")
                return False


    async def jian_biao(self,sql):
        # 在脚本开头添加警告过滤器，忽略表已存在的警告：
        import warnings
        from aiomysql import Warning
        # 忽略建表时,表已经存在警告
        warnings.filterwarnings("ignore", category=Warning, message="Table.*already exists")

        if not self.__pool:
            raise RuntimeError("连接池未初始化，请先调用 create_pool()")

        async with self.__pool.acquire() as conn:
            async with conn.cursor() as cursor:
                try:
                    await cursor.execute(sql)
                    # 将当前事务中所有未提交的数据库更改（如插入、更新、删除）永久保存到数据库
                    await conn.commit()
                    print(f"操作成功")
                    return True
                except aiomysql.Error as e:
                    print(f"操作失败: {e}")
                    # 回滚当前未提交的事务
                    await conn.rollback()
                    return False


    async def jian_biao_01(self,sql):
        async with self.__pool.acquire() as conn:
            async with conn.cursor() as cursor:
                try:
                    await cursor.execute(sql)
                    # 将当前事务中所有未提交的数据库更改（如插入、更新、删除）永久保存到数据库
                    await conn.commit()
                    print(f"操作成功")
                    return True
                except aiomysql.Error as e:
                    print(f"操作失败: {e}")
                    # 回滚当前未提交的事务
                    await conn.rollback()
                    return False






async def run():
    await AsyncMYSQL_CZ.create_pool()
    ss = AsyncMYSQL_CZ()
    db = SQL_YU_JI_l()
    await ss.jian_biao(db.jb_zd_zi_ding_yi)
    # 手动关闭连接池
    await AsyncMYSQL_CZ.close_pool()

if __name__ == '__main__':
    #asyncio.run(run())

    # ------------ 业务方法（保持原有接口不变）------------


    async def cha_zhao(self) -> List[Tuple]:
        """执行查询操作（示例）
        -> 符号：这是 Python 的函数返回值类型标注语法，用于声明函数返回值的类型
        List[Tuple] 表示返回值是一个列表（List），列表中的每个元素是一个元组（Tuple）
        """
        sql = "SELECT * FROM zu_fang WHERE zhua_qu_shi_jian > 1726043431"
        return await self.execute_query(sql)

    async def cha_zhao_tpm(self, tu_pian_bao_cun: str) -> List[Tuple]:
        """查找图片保存名"""
        sql = "SELECT tu_pian_bao_cun FROM zu_fang WHERE tu_pian_bao_cun LIKE %s"
        return await self.execute_query(sql, (tu_pian_bao_cun,))

    async def cha_xun_tp_jg(self, tu_pian_bao_cun_c: str, jia_ge_c: float) -> List[Tuple]:
        """查找相同图片和价格的数据"""
        sql = """SELECT tu_pian_bao_cun, jia_ge, zhua_qu_shi_jian 
               FROM zu_fang 
               WHERE tu_pian_bao_cun LIKE %s AND jia_ge = %s"""
        return await self.execute_query(sql, (tu_pian_bao_cun_c, jia_ge_c))

    async def zeng_jia(self, ping_fang: str, gong_si: str, biao_ti: str, zhua_qu_shi_jian: int) -> bool:
        """异步插入数据"""
        sql = """INSERT INTO zu_fang(ping_fang, gong_si, biao_ti, zhua_qu_shi_jian)
               VALUES (%s, %s, %s, %s)"""
        return await self.execute_update(sql, (ping_fang, gong_si, biao_ti, zhua_qu_shi_jian))

'''
async def main():
    # 初始化连接池
    await AsyncMYSQL_CZ.create_pool()

    # 创建操作实例
    db = AsyncMYSQL_CZ()

    # 示例查询
    results = await db.cha_zhao()
    if results:
        for row in results:
            print(row)

    # 示例插入
    success = await db.zeng_jia(
        ping_fang="80㎡",
        gong_si="链家",
        biao_ti="朝阳区精装两居",
        zhua_qu_shi_jian=1726043431
    )
    print(f"插入操作结果: {'成功' if success else '失败'}")

    # 关闭连接池
    await AsyncMYSQL_CZ.close_pool()

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())
'''


# MYSQL同步连接池
class MYSQL_CZ:  # mysql操作
    # close_all_connections() 关闭所有连接,不推荐使用.这个连接是自动关闭的
    __host = '106.14.158.84'
    __port = 3306
    __database = 'pa_chong'
    __user = 'a18222970'
    __password = 'cx123100'

    # 创建一个PooledDB实例，它将创建一个连接池
    __pool = PooledDB(
        creator=pymysql,  # 使用pymysql数据库连接
        host=__host,
        user=__user,
        password=__password,
        database=__database,
        port=__port,
        maxconnections=6,  # 连接池允许的最大连接数
        mincached=3,  # 初始化时，连接池中至少创建的空闲连接数
        maxcached=6,  # 连接池中最多缓存多少个空闲连接
        maxusage=None,  # 一个连接最多被重复使用的次数，None表示无限制
        blocking=True,  # 连接池用完时，请求连接是否阻塞
        setsession=[],  # 开始会话前执行的命令列表
        ping=4  # ping MySQL服务端，检查是否存活
    )

    @classmethod
    def get_connection(cls):
        """从连接池获取一个连接"""
        return cls.__pool.connection()

    def cha_zhao(self):
        """执行查询操作"""
        conn = self.get_connection()
        cursor = conn.cursor()
        # select 字段(*) from 表 条件
        sql = """
        select * from zu_fang where zhua_qu_shi_jian > 1726043431
        """
        try:
            """ fetchone
            cursor.execute(sql)
            # fetchone 返回1条数据,调用1次向后返回1条数据
            # result = cursor.fetchone()
            while True:
                result = cursor.fetchone()
                if result:
                    print(result)
                else:
                    break
            """
            """
            cursor.execute(sql)
            # fetchall 1次性返回全部结果
            results = cursor.fetchall()
            for result in results:
                print(result)
            """

            cursor.execute(sql)
            # fetchmany 1次性返回指定条数数据(2)结果
            results = cursor.fetchmany(2)
            for result in results:
                print(result)

        except pymysql.Error as e:
            print(f"查询失败: {e}")
        finally:
            cursor.close()
            conn.close()  # 关闭连接，实际上是将连接返回到连接池

    # 查找租房数据表中保存的图片名
    def cha_zhao_tpm(self,tu_pian_bao_cun):
        """执行查询操作"""
        conn = self.get_connection()
        cursor = conn.cursor()
        # select 字段(*) from 表 条件
        sql = """
        SELECT tu_pian_bao_cun FROM zu_fang WHERE tu_pian_bao_cun LIKE %s
        """
        try:
            cursor.execute(sql,(tu_pian_bao_cun,))
            # fetchall 1次性返回全部结果
            results = cursor.fetchall()
        except pymysql.Error as e:
            print(f"查询失败: {e}")
            results = None
        finally:
            cursor.close()
            conn.close()  # 关闭连接，实际上是将连接返回到连接池

        return results

    """
    查找租房表里相同的图片名和相同房租价格的数据
    参数:
    tu_pian_bao_cun_c: 要查找的图片名
    jia_ge_c:          查找的房租价格
    返回: tu_pian_bao_cun, jia_ge, zhua_qu_shi_jian
    """
    def cha_xun_tp_jg(self,tu_pian_bao_cun_c,jia_ge_c):
        """执行查询操作"""
        conn = self.get_connection()
        cursor = conn.cursor()
        try:
            # sql = "SELECT tu_pian_bao_cun, jia_ge, zhua_qu_shi_jian FROM zu_fang WHERE tu_pian_bao_cun LIKE %s"
            sql = "SELECT tu_pian_bao_cun, jia_ge, zhua_qu_shi_jian FROM zu_fang WHERE tu_pian_bao_cun LIKE %s AND jia_ge = %s"
            cursor.execute(sql, (tu_pian_bao_cun_c,jia_ge_c,))
            results = cursor.fetchall() # fetchall方法返回的是一个元组组成的列表

        except pymysql.Error as e:
            print(f"查询失败: {e}")
            results = None
        finally:
            cursor.close()
            conn.close()  # 关闭连接，实际上是将连接返回到连接池

        return results


    def zeng_jia(self, ping_fang, gong_si, biao_ti, zhua_qu_shi_jian):
        """执行插入操作"""
        conn = self.get_connection()
        cursor = conn.cursor()
        sql = """
            INSERT INTO zu_fang(ping_fang, gong_si, biao_ti, zhua_qu_shi_jian)
            VALUES (%s, %s, %s, %s)
        """
        try:
            cursor.execute(sql, (ping_fang, gong_si, biao_ti, zhua_qu_shi_jian))
            conn.commit()
        except pymysql.Error as e:
            print(f"插入失败: {e}")
            # 所有在当前事务中进行的更改都会被撤销
            conn.rollback()
        finally:
            cursor.close()
            conn.close()  # 关闭连接，实际上是将连接返回到连接池

    """
    往 zu_fang 表里添加一条数据,参数:
    tu_pian_di_zhi : 图片的网络地址
    tu_pian_bao_cun: 图片的本地保存的名字,带扩展名
    ping_fang:       租房的面积
    gong_si:         发布信息的中介公司
    biao_ti:         发布的标题
    jia_ge:          房租价格
    fa_bu_ri_qi:     发布日期
    lian_jie:        租房信息具体页面地址
    zhua_qu_shi_jian:抓取信息的时间,以时间戳保存
    """
    def zj_zu_fang_tiao_mu(self, tu_pian_di_zhi, tu_pian_bao_cun, ping_fang, gong_si, biao_ti, jia_ge, fa_bu_ri_qi,
                         lian_jie, zhua_qu_shi_jian):
        """执行插入操作"""
        conn = self.get_connection()
        cursor = conn.cursor()
        sql = """
            INSERT INTO zu_fang(tu_pian_di_zhi, tu_pian_bao_cun, ping_fang, gong_si,biao_ti,jia_ge,fa_bu_ri_qi,lian_jie,zhua_qu_shi_jian)
            VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s)
        """
        try:
            cursor.execute(sql, (
            tu_pian_di_zhi, tu_pian_bao_cun, ping_fang, gong_si, biao_ti, jia_ge, fa_bu_ri_qi, lian_jie,
            zhua_qu_shi_jian,))
            conn.commit()
        except pymysql.Error as e:
            print(f"插入失败: {e}")
            # 所有在当前事务中进行的更改都会被撤销
            conn.rollback()
            return -1
        finally:
            cursor.close()
            conn.close()  # 关闭连接，实际上是将连接返回到连接池
            return 0


    """
    =============     二手房     =======================
    """

    """
    查询mai_fang表中信息标题与房屋卖价都相同的数据
    参数:
    sf_biaoTi: 信息标题
    sf_mianJi: 房屋卖价
    返回:售房标题, 售房卖价, 抓取时间
    """
    def cx_er_shou_fang_bt_sj(self,sf_biaoTi,sf_maiJi):
        """执行查询操作"""
        conn = self.get_connection()
        cursor = conn.cursor()
        try:
            # sql = "SELECT tu_pian_bao_cun, jia_ge, zhua_qu_shi_jian FROM zu_fang WHERE tu_pian_bao_cun LIKE %s"
            sql = "SELECT 售房标题, 售房卖价, 抓取时间 FROM mai_fang WHERE 售房标题 LIKE %s AND 售房卖价 = %s"
            cursor.execute(sql, (sf_biaoTi,sf_maiJi,))
            results = cursor.fetchall() # fetchall方法返回的是一个元组组成的列表

        except pymysql.Error as e:
            print(f"查询失败: {e}")
            results = None
        finally:
            cursor.close()
            conn.close()  # 关闭连接，实际上是将连接返回到连接池

        return results

    def cx_xiao_qu_shi_jian_cuo(self):
        """执行查询操作，获取id最大对应的抓取时间"""
        conn = self.get_connection()
        cursor = conn.cursor()
        try:
            # 使用 MAX 函数来获取 抓取时间 字段的最大值
            sql = "SELECT MAX(时间) FROM er_shou_fang_jun_jia"
            cursor.execute(sql)
            result = cursor.fetchone()  # fetchone方法返回的是单行结果
            result = result[0]

        except pymysql.Error as e:
            print(f"查询失败: {e}")
            result = None
        finally:
            cursor.close()
            conn.close()  # 关闭连接，实际上是将连接返回到连接池

        return result

    def cx_xiao_qu_jj(self,shiJian,junJia):
        """执行查询操作"""
        conn = self.get_connection()
        cursor = conn.cursor()
        try:
            # sql = "SELECT tu_pian_bao_cun, jia_ge, zhua_qu_shi_jian FROM zu_fang WHERE tu_pian_bao_cun LIKE %s"
            sql = "SELECT 小区 FROM er_shou_fang_jun_jia WHERE 时间 = %s AND 均价 = %s"
            cursor.execute(sql, (shiJian,junJia,))
            result = cursor.fetchone() # fetchone方法返回的是单行结果果

        except pymysql.Error as e:
            print(f"查询失败: {e}")
            result = None
        finally:
            cursor.close()
            conn.close()  # 关闭连接，实际上是将连接返回到连接池

        return result

    """
        往 zu_fang 表里添加一条数据,参数:
        售房面积, 售房卖价, 售房平方均价, 售房信息连接, 售房标题, 售房地址, 建造年代, 抓取时间
    """

    def zj_er_shou_fang_tiao_mu(self, sf_mianJi, sf_mai_jia, sf_jun_jia, xx_lian_jie, sf_biaoTi, sf_di_zhi, sf_nian_dai,
                           zhua_qu_shi_jian):
        """执行插入操作"""
        conn = self.get_connection()
        cursor = conn.cursor()
        sql = """
                INSERT INTO mai_fang(售房面积, 售房卖价, 售房平方均价, 售房信息连接, 售房标题, 售房地址, 建造年代, 抓取时间)
                VALUES (%s,%s,%s,%s,%s,%s,%s,%s)
            """
        try:
            cursor.execute(sql, (
                sf_mianJi, sf_mai_jia, sf_jun_jia, xx_lian_jie, sf_biaoTi, sf_di_zhi, sf_nian_dai, zhua_qu_shi_jian,))
            conn.commit()
        except pymysql.Error as e:
            print(f"插入失败: {e}")
            # 所有在当前事务中进行的更改都会被撤销
            conn.rollback()
            return -1
        finally:
            cursor.close()
            conn.close()  # 关闭连接，实际上是将连接返回到连接池
            return 0

    """
    增加小区平均价格数据
    """
    def zj_xiao_qu_jun_jia(self, zhua_qu_shi_jian, xq_jun_jia, xiao_qu):
        """执行插入操作"""
        conn = self.get_connection()
        cursor = conn.cursor()
        sql = """
                INSERT INTO er_shou_fang_jun_jia(时间, 均价, 小区) VALUES (%s,%s,%s)
            """
        try:
            cursor.execute(sql, (zhua_qu_shi_jian, xq_jun_jia, xiao_qu,))
            conn.commit()
        except pymysql.Error as e:
            print(f"插入失败: {e}")
            # 所有在当前事务中进行的更改都会被撤销
            conn.rollback()
            return -1
        finally:
            cursor.close()
            conn.close()  # 关闭连接，实际上是将连接返回到连接池
            return 0

    # 删除
    def shan_chu(self):
        """执行删除操作"""
        conn = self.get_connection()
        cursor = conn.cursor()
        sql = """
        DELETE FROM zu_fang WHERE ping_fang = '43.16'
        """
        try:
            cursor.execute(sql)
            conn.commit()
        except pymysql.Error as e:
            print(f"删除失败: {e}")
            # rollback 所有在当前事务中进行的更改都会被撤销
            conn.rollback()
        finally:
            cursor.close()
            conn.close()  # 关闭连接，实际上是将连接返回到连接池

    # 清空zu_fang表
    def qing_kong_zu_fang(self):
        """执行删除操作"""
        conn = self.get_connection()
        cursor = conn.cursor()
        sql = """
        DELETE FROM zu_fang
        """
        try:
            cursor.execute(sql)
            conn.commit()
        except pymysql.Error as e:
            print(f"删除失败: {e}")
            # rollback 所有在当前事务中进行的更改都会被撤销
            conn.rollback()
        finally:
            cursor.close()
            conn.close()  # 关闭连接，实际上是将连接返回到连接池

    # 清空mai_fang表
    def qing_kong_mai_fang(self):
        """执行删除操作"""
        conn = self.get_connection()
        cursor = conn.cursor()
        sql = """
        DELETE FROM mai_fang
        """
        try:
            cursor.execute(sql)
            conn.commit()
        except pymysql.Error as e:
            print(f"删除失败: {e}")
            # rollback 所有在当前事务中进行的更改都会被撤销
            conn.rollback()
        finally:
            cursor.close()
            conn.close()  # 关闭连接，实际上是将连接返回到连接池


    """
    清空指定表里的全部数据
    参数:
    biao: 要清空的表名
    """
    def qing_kong_biao(self,biao):
        """执行删除操作"""
        conn = self.get_connection()
        cursor = conn.cursor()
        sql = f"""
        DELETE FROM {biao}
        """
        try:
            cursor.execute(sql)
            conn.commit()
        except pymysql.Error as e:
            print(f"删除失败: {e}")
            # rollback 所有在当前事务中进行的更改都会被撤销
            conn.rollback()
        finally:
            cursor.close()
            conn.close()  # 关闭连接，实际上是将连接返回到连接池

    def geng_xin(self):
        """执行更新操作"""
        conn = self.get_connection()
        cursor = conn.cursor()
        sql = """
        UPDATE zu_fang SET biao_ti = '绝代风华' WHERE zhua_qu_shi_jian = 12549988776644123
        """
        try:
            cursor.execute(sql)
            conn.commit()
        except pymysql.Error as e:
            print(f"更新失败: {e}")
            # rollback 所有在当前事务中进行的更改都会被撤销
            conn.rollback()
        finally:
            cursor.close()
            conn.close()  # 关闭连接，实际上是将连接返回到连接池

    def zj(self,ccxx,aass):
        conn = self.get_connection()
        cursor = conn.cursor()
        sql = """
                    INSERT INTO cs(ccxx, aass)
                    VALUES (%s, %s)
                """
        try:
            cursor.execute(sql, (ccxx, aass))
            conn.commit()
        except pymysql.Error as e:
            print(f"插入失败: {e}")
            # 所有在当前事务中进行的更改都会被撤销
            conn.rollback()
        finally:
            cursor.close()
            conn.close()  # 关闭连接，实际上是将连接返回到连接池

    """  =================  外部修改获取类私有属性方法 ================"""

    def get_database(self):
        """获取当前__database的值"""
        return self.__database

    def set_database(self, database):
        """设置__database的值"""
        if database:
            self.__database = database

    def get_host(self):
        return self.__host

    def set_host(self, host):
        if host:
            self.__host = host

    def get_user(self):
        return self.__user

    def set_user(self, user):
        if user:
            self.__user = user

    def get_password(self):
        return self.__password

    def set_password(self, password):
        if password:
            self.__password = password


class MYSQL_PT:
    __host = '192.168.1.88'
    __port = 3306
    __database = 'zhi_neng_wang_guan'
    __user = 'a18222970'
    __password = 'cx123100'  # 私有类变量

    def __init__(self):
        self.__conn = None
        self.__cursor = None
        self.connect_db()  # 初始化时建立数据库连接


    def __del__(self):
        self.close_db()  # 类销毁时关闭数据库连接

    def connect_db(self):
        """连接数据库"""
        try:
            self.__conn = pymysql.connect(
                host=self.__host,
                user=self.__user,
                password=self.__password,
                database=self.__database,
                port=self.__port
            )
            self.__cursor = self.__conn.cursor()
        except pymysql.Error as e:
            print(f"数据库连接失败: {e}")

    def close_db(self):
        """关闭数据库连接"""
        if self.__cursor:
            self.__cursor.close()
        if self.__conn:
            self.__conn.close()

    #查询大于参数id的tu_pian_bao_cun字段所有数据,
    def cha_xun_01(self,id):
        """执行查询操作"""
        try:
            sql = "SELECT tu_pian_bao_cun FROM zu_fang WHERE id > %s"
            self.__cursor.execute(sql, (id,))
            results = self.__cursor.fetchall() # fetchall方法返回的是一个元组组成的列表
            #print(results)
            return results
        except pymysql.Error as e:
            print(f"查询失败: {e}")

    def cha_xun_02(self,tu_pian_bao_cun_c,jia_ge_c):
        """执行查询操作"""
        try:
            # sql = "SELECT tu_pian_bao_cun, jia_ge, zhua_qu_shi_jian FROM zu_fang WHERE tu_pian_bao_cun LIKE %s"
            sql = "SELECT tu_pian_bao_cun, jia_ge, zhua_qu_shi_jian FROM zu_fang WHERE tu_pian_bao_cun LIKE %s AND jia_ge = %s"
            self.__cursor.execute(sql, (tu_pian_bao_cun_c,jia_ge_c,))
            results = self.__cursor.fetchall() # fetchall方法返回的是一个元组组成的列表
            return results
        except pymysql.Error as e:
            print(f"查询失败: {e}")


    """
    
    """
    def cha_xun_zu_fang_jia_ge(self,shijian):
        try:
            sql = "SELECT jia_ge, zhua_qu_shi_jian FROM zu_fang WHERE zhua_qu_shi_jian > %s"
            self.__cursor.execute(sql, (shijian,))
            results = self.__cursor.fetchall()  # fetchall方法返回的是一个元组组成的列表
            return results
        except pymysql.Error as e:
            print(f"查询失败: {e}")























